/**
 * WebSocket管理器 - 用于与后端TCP服务器通信
 */
import { ElNotification, ElMessage } from 'element-plus'
import store from '@/store'
import useChatStore from '@/store/modules/chat'
import { getToken } from '@/utils/auth'
import { useAgentStore } from '@/store/modules/agent'

class WebSocketManager {
  constructor() {
    this.ws = null
    this.reconnectTimer = null
    this.heartbeatTimer = null
    this.reconnectDelay = 5000 // 5秒重连
    this.heartbeatInterval = 30000 // 30秒心跳
    this.url = null
    this.isConnecting = false
    this.messageHandlers = [] // 消息处理器列表
    
    // 从环境变量读取配置
    this.protocol = import.meta.env.VITE_WS_PROTOCOL || 'ws'
    // 如果 VITE_WS_HOST 为空或为 'auto'，则使用当前页面的 hostname
    const envHost = import.meta.env.VITE_WS_HOST
    this.host = (!envHost || envHost === 'auto') ? window.location.hostname : envHost
    this.port = import.meta.env.VITE_WS_PORT || '9099'
    this.path = import.meta.env.VITE_WS_PATH || '/ws'
    this.authEnabled = import.meta.env.VITE_WS_AUTH_ENABLED === 'true'
    
    // ✅ 初始化时请求浏览器通知权限
    this.requestNotificationPermission()
  }
  
  /**
   * 请求浏览器通知权限
   */
  async requestNotificationPermission() {
    if ('Notification' in window) {
      if (Notification.permission === 'default') {
        // 延迟请求权限，避免在页面加载时立即弹出
        setTimeout(async () => {
          try {
            await Notification.requestPermission()
          } catch (e) {
            console.debug('[WebSocket] 通知权限请求失败:', e)
          }
        }, 2000)
      }
    }
  }

  /**
   * 连接WebSocket
   * @param {string} url WebSocket URL（可选，不传则使用环境变量配置）
   */
  connect(url) {
    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
      console.log('WebSocket已连接')
      return
    }

    if (this.isConnecting) {
      console.log('WebSocket正在连接中...')
      return
    }

    // 如果没有传入url，则根据环境变量构建
    if (!url) {
      url = `${this.protocol}://${this.host}:${this.port}${this.path}`
      
      // 如果启用认证，添加Token
      if (this.authEnabled) {
        // ✅ 使用 getToken() 从 Cookie 获取 token（与 API 请求保持一致）
        const token = getToken()
        if (token) {
          url += `?token=${encodeURIComponent(token)}`
          console.log(`✅ WebSocket认证：已添加token（长度=${token.length}）`)
        } else {
          console.warn('⚠️ WebSocket认证：未找到token，连接可能失败')
        }
      }
    }
    
    this.url = url
    console.log(`使用配置: ${this.protocol}://${this.host}:${this.port}${this.path}`)
    console.log(`认证: ${this.authEnabled ? '启用' : '禁用'}`)

    this.isConnecting = true
    console.log(`连接WebSocket: ${this.url}`)

    try {
      this.ws = new WebSocket(this.url)

      this.ws.onopen = () => {
        console.log('✅ WebSocket连接成功')
        this.isConnecting = false
        this.startHeartbeat()
        
        // 通知所有处理器连接成功
        this.notifyHandlers({ type: 'connected' })
        
        ElNotification({
          title: 'WebSocket',
          message: '已连接到服务器',
          type: 'success',
          duration: 2000
        })
      }

      this.ws.onmessage = (event) => {
        try {
          const data = JSON.parse(event.data)
          // console.log('📨 收到消息:', data) // ✅ 已注释：日志太多，影响调试
          this.handleMessage(data)
        } catch (error) {
          console.error('解析消息失败:', error)
        }
      }

      this.ws.onerror = (error) => {
        console.error('❌ WebSocket错误:', error)
        this.isConnecting = false
      }

      this.ws.onclose = () => {
        console.log('❌ WebSocket连接关闭')
        this.isConnecting = false
        this.stopHeartbeat()
        this.notifyHandlers({ type: 'disconnected' })
        
        // 自动重连
        this.scheduleReconnect()
      }
    } catch (error) {
      console.error('创建WebSocket失败:', error)
      this.isConnecting = false
      this.scheduleReconnect()
    }
  }

  /**
   * 处理接收到的消息
   */
  handleMessage(data) {
    const { type } = data

    switch (type) {
      case 'init':
        // 初始化消息（客户端列表）
        this.notifyHandlers(data)
        break
      
      case 'client_update':
      case 'status_update':
        // 客户端状态更新
        // ✅ 同时更新agentStore（确保所有页面都能访问最新的客户端状态）
        this.handleStatusUpdate(data)
        this.notifyHandlers(data)
        break
      
      case 'client_response':
        // 客户端响应消息（登录、搜索、下单等）
        this.handleClientResponse(data)
        break
      
      case 'client_disconnected':
        // 客户端离线
        ElNotification({
          title: '客户端离线',
          message: `客户端 ${data.client_id} 已离线`,
          type: 'warning',
          duration: 3000
        })
        this.notifyHandlers(data)
        break
      
      case 'chat_message':
        // 聊天消息（旧格式，保留兼容）
        this.handleChatMessage(data)
        break
      
      case 'message_event':
        // 消息事件（新格式，Event驱动）
        this.handleMessageEvent(data)
        break
      
      default:
        // 其他消息类型
        this.notifyHandlers(data)
    }
  }

  /**
   * 处理消息事件（新格式，Event驱动）
   */
  handleMessageEvent(data) {
    const { client_id, event, data: eventData } = data
    
    // 导入消息状态
    import('@/utils/messageStatus').then(({ MessageStatus, MessageEvent, canTransition }) => {
      const chatStore = useChatStore()
      
      // ✅ 过滤：只处理当前选中客户端的消息
      if (!chatStore.selectedClientId) {
        chatStore.selectClient(client_id)
        console.log('[WebSocket] 自动选择客户端:', client_id)
      } else if (chatStore.selectedClientId !== client_id) {
        console.debug('[WebSocket] 忽略其他客户端的消息事件:', client_id)
        return
      }
      
      // 构建会话ID
      const sessionId = eventData.conversation_id || 
        eventData.chat_id ||
        `${eventData.seller_id || ''}#${eventData.item_id || ''}`
      
      console.log('[WebSocket] 📨 收到消息事件:', {
        event,
        tempId: eventData.temp_id,
        messageId: eventData.message_id,
        sessionId
      })
      
      // 根据事件类型处理
      switch (event) {
        case MessageEvent.CREATED:
          // 消息已创建（后端记录已保存）
          this.handleMessageCreated(sessionId, eventData, chatStore)
          break
        
        case MessageEvent.CONFIRMED:
          // 消息已确认（官方响应已收到）
          this.handleMessageConfirmed(sessionId, eventData, chatStore)
          break
        
        case MessageEvent.RECALLED:
          // 消息已撤回
          this.handleMessageRecalled(sessionId, eventData, chatStore)
          break
        
        case MessageEvent.FAILED:
          // 消息发送失败
          this.handleMessageFailed(sessionId, eventData, chatStore)
          break
        
        default:
          console.warn('[WebSocket] 未知消息事件:', event)
      }
    })
  }

  /**
   * 处理消息创建事件
   */
  handleMessageCreated(sessionId, eventData, chatStore) {
    import('@/utils/messageStatus').then(({ MessageStatus }) => {
      const tempId = eventData.temp_id
      
      // 查找临时消息
      const existingMsg = chatStore.findMessageByTempId(sessionId, tempId)
      
      if (existingMsg) {
        // 更新临时消息：CREATING/PENDING -> PENDING
        if (existingMsg.messageStatus < MessageStatus.SENT) {
          chatStore.updateMessageByTempId(sessionId, tempId, {
            messageId: eventData.message_id,
            messageStatus: MessageStatus.PENDING,
            pending: true
          })
          console.log('[WebSocket] ✅ 消息已创建:', {
            tempId,
            messageId: eventData.message_id
          })
        } else {
          // 消息已经确认了，忽略创建事件（时序错乱）
          console.debug('[WebSocket] 消息已确认，忽略创建事件:', tempId)
        }
      } else {
        // 临时消息不存在（可能是接收的消息），创建新消息
        console.warn('[WebSocket] 未找到临时消息，创建新消息:', tempId)
      }
    })
  }

  /**
   * 处理消息确认事件
   */
  handleMessageConfirmed(sessionId, eventData, chatStore) {
    import('@/utils/messageStatus').then(({ MessageStatus }) => {
      const tempId = eventData.temp_id
      const realMessageId = eventData.message_id
      
      console.log('[WebSocket] 🔍 handleMessageConfirmed 开始:', {
        sessionId,
        tempId,
        realMessageId,
        eventData
      })
      
      // 查找临时消息
      let existingMsg = chatStore.findMessageByTempId(sessionId, tempId)
      let actualSessionId = sessionId
      
      // ✅ 如果在当前会话中找不到，尝试在所有会话中查找（可能sessionId不匹配）
      if (!existingMsg) {
        for (const [sid, messages] of Object.entries(chatStore.messages)) {
          const msg = messages.find(m => m.tempId === tempId)
          if (msg) {
            existingMsg = msg
            actualSessionId = sid
            console.warn('[WebSocket] ⚠️ sessionId不匹配，在其他会话中找到了临时消息:', {
              expectedSessionId: sessionId,
              actualSessionId: sid,
              tempId
            })
            break
          }
        }
      }
      
      console.log('[WebSocket] 🔍 查找临时消息结果:', {
        found: !!existingMsg,
        sessionId: actualSessionId,
        existingMsg: existingMsg ? {
          tempId: existingMsg.tempId,
          messageId: existingMsg.messageId,
          messageStatus: existingMsg.messageStatus
        } : null
      })
      
      if (existingMsg) {
        // 更新临时消息：PENDING -> SENT（使用实际的sessionId）
        const updated = chatStore.updateMessageByTempId(actualSessionId, tempId, {
          messageId: realMessageId,  // 更新为真实消息ID
          messageStatus: MessageStatus.SENT,
          pending: false,
          status: 'success', // 兼容旧状态
          // 如果是图片消息，更新图片URL
          image_url: eventData.image_url || existingMsg.image_url,
          image_width: eventData.image_width || existingMsg.image_width,
          image_height: eventData.image_height || existingMsg.image_height
        })
        
        console.log('[WebSocket] ✅ 消息已确认:', {
          tempId,
          realMessageId,
          type: eventData.message_type,
          updated,
          sessionId: actualSessionId
        })
        
        // ✅ 如果 sessionId 不匹配，需要处理会话迁移
        if (actualSessionId !== sessionId) {
          console.warn('[WebSocket] 🔄 sessionId 已变化，开始迁移消息:', {
            oldSessionId: actualSessionId,
            newSessionId: sessionId
          })
          
          // 检查新会话是否存在
          if (chatStore.messages[sessionId]) {
             // 新会话已存在，将消息移动过去（避免覆盖新会话的历史消息）
             console.log('[WebSocket] ⚠️ 新会话已存在，执行消息合并')
             
             // 1. 从旧会话移除该消息
             const oldMsgIndex = chatStore.messages[actualSessionId].findIndex(m => m.tempId === tempId)
             let msgToMove = existingMsg
             if (oldMsgIndex !== -1) {
                // 创建副本并移除原消息
                msgToMove = { ...chatStore.messages[actualSessionId][oldMsgIndex] }
                chatStore.messages[actualSessionId].splice(oldMsgIndex, 1)
             }
             
             // 2. 检查新会话是否已包含该消息（防止重复）
             const existsInNew = chatStore.messages[sessionId].some(m => m.tempId === tempId || m.messageId === realMessageId)
             if (!existsInNew) {
                 chatStore.messages[sessionId].push(msgToMove)
                 // 重新排序
                 chatStore.messages[sessionId].sort((a, b) => new Date(a.message_time) - new Date(b.message_time))
             }
             
             // 3. 如果旧会话为空，删除旧会话
             if (chatStore.messages[actualSessionId].length === 0) {
                 delete chatStore.messages[actualSessionId]
                 // 同时也清理会话列表中的旧会话
                 const sessionIndex = chatStore.sessions.findIndex(s => s.sessionId === actualSessionId)
                 if (sessionIndex !== -1) {
                     chatStore.sessions.splice(sessionIndex, 1)
                 }
             }
          } else {
             // 新会话不存在，直接重命名旧会话（安全迁移）
             console.log('[WebSocket] ✅ 新会话不存在，执行整体迁移')
             const oldMessages = chatStore.messages[actualSessionId] || []
             chatStore.messages[sessionId] = oldMessages
             delete chatStore.messages[actualSessionId]
             
             // 更新会话列表中的 sessionId
             const sessionIndex = chatStore.sessions.findIndex(s => s.sessionId === actualSessionId)
             if (sessionIndex !== -1) {
                chatStore.sessions[sessionIndex].sessionId = sessionId
             }
          }
          
          // 4. 如果当前选中的是旧会话，更新为新会话
          if (chatStore.currentSessionId === actualSessionId) {
            chatStore.currentSessionId = sessionId
            console.log('[WebSocket] ✅ 已更新当前选中的 sessionId')
          }
        }
      } else {
        // 临时消息不存在（时序错乱：CONFIRMED先到），直接创建已发送消息
        console.warn('[WebSocket] ⚠️ 临时消息不存在，直接创建已发送消息:', tempId)
        // 检查是否已存在相同messageId的消息（防止重复）
        const isDuplicate = (chatStore.messages[sessionId] || []).some(m => m.messageId === realMessageId)
        if (!isDuplicate) {
            const msg = {
              tempId: tempId,
              messageId: realMessageId,
              direction: eventData.direction || 'send',
              message_type: eventData.message_type || 'text',
              message_content: eventData.message_content,
              message_time: eventData.message_time || new Date().toISOString(),
              messageStatus: MessageStatus.SENT,
              pending: false,
              status: 'success'
            }
            
            // 添加图片信息
            if (eventData.message_type === 'image') {
              msg.image_url = eventData.image_url
              msg.image_width = eventData.image_width
              msg.image_height = eventData.image_height
            }
            
            chatStore.appendMessages(sessionId, [msg])
        }
      }
    })
  }

  /**
   * 处理消息撤回事件
   */
  handleMessageRecalled(sessionId, eventData, chatStore) {
    import('@/utils/messageStatus').then(({ MessageStatus }) => {
      const messageId = eventData.message_id
      
      // 通过 messageId 更新消息
      const success = chatStore.updateMessageById(sessionId, messageId, {
        messageStatus: MessageStatus.RECALLED,
        pending: false,
        recalled: true
      })
      
      if (success) {
        console.log('[WebSocket] ✅ 消息已撤回:', messageId)
      } else {
        console.warn('[WebSocket] 未找到要撤回的消息:', messageId)
      }
    })
  }

  /**
   * 处理消息失败事件
   */
  handleMessageFailed(sessionId, eventData, chatStore) {
    import('@/utils/messageStatus').then(({ MessageStatus }) => {
      const tempId = eventData.temp_id
      
      // 通过 tempId 更新消息
      const success = chatStore.updateMessageByTempId(sessionId, tempId, {
        messageStatus: MessageStatus.FAILED,
        pending: false,
        error: eventData.error || '发送失败'
      })
      
      if (success) {
        console.log('[WebSocket] ❌ 消息发送失败:', tempId, eventData.error)
      } else {
        console.warn('[WebSocket] 未找到失败的消息:', tempId)
      }
    })
  }

  /**
   * 处理聊天消息（旧格式，保留兼容）
   */
  handleChatMessage(data) {
    const { client_id, data: messageData } = data
    
    // 通知聊天 store
    const chatStore = useChatStore()
    
    // ✅ 修复：只接收当前选中客户端的消息，过滤掉其他客户端的消息
    if (!chatStore.selectedClientId) {
      // ✅ 如果没有选中客户端，自动选择消息来源的客户端
      chatStore.selectClient(client_id)
      console.log('[WebSocket] 自动选择客户端:', client_id)
    } else if (chatStore.selectedClientId !== client_id) {
      // ❌ 如果已选中客户端但与消息来源不同，忽略这条消息
      console.debug('[WebSocket] 忽略其他客户端的消息:', client_id, '当前选中:', chatStore.selectedClientId)
      return // ✅ 关键：直接返回，不处理这条消息
    }
    
    // 构建会话ID
    // ✅ 优先使用conversation_id（可能包含chat_id），如果没有则使用chat_id，最后才使用seller_id#item_id
    const sessionId = messageData.conversation_id || 
      messageData.chat_id ||
      `${messageData.seller_id || ''}#${messageData.item_id || ''}`
    
    // ✅ 如果是发送的消息（direction='send'），不应该更新sellerName
    // 因为发送消息时，seller_id是正确的，但seller_name可能为空或错误
    // 只更新lastMessage和lastTime，保留原有的sellerName
    const is_sent_message = messageData.direction === 'send'
    
    // ✅ 更新会话信息（包含seller_avatar）
    // ⚠️ 重要：只更新消息数据中存在的字段，保留已有的商品信息（itemTitle, itemImage, itemPrice等）
    // ✅ 关键：必须传递sessionId，确保使用conversation_id（可能包含chat_id）而不是重新构建
    // ⚠️ 重要：对于发送的消息（direction='send'），不应该更新sellerId和itemId
    // 因为发送消息时的seller_id可能是发送方的ID（错误的），而不是接收方的ID
    const sessionUpdate = {
      sessionId: sessionId,  // ✅ 传递构建好的sessionId（优先使用conversation_id或chat_id）
      lastTime: messageData.message_time
    }
    
    // ✅ 只有接收消息时才更新sellerId和itemId（确保使用正确的卖家ID）
    if (!is_sent_message) {
      if (messageData.seller_id) {
        sessionUpdate.sellerId = messageData.seller_id
      }
      if (messageData.item_id) {
        sessionUpdate.itemId = messageData.item_id
      }
    }
    
    // ✅ 对于系统消息，不应该将message_content用作lastMessage（可能包含HTML标签）
    // 应该使用系统消息的title或一个固定的提示文本
    if (messageData.message_type === 'system' && messageData.system_data) {
      // 系统消息：使用title作为lastMessage，如果没有title则使用固定文本
      sessionUpdate.lastMessage = messageData.system_data.title || '[系统消息]'
    } else {
      // 普通消息：使用message_content作为lastMessage
      sessionUpdate.lastMessage = messageData.message_content
    }
    
    // 只添加存在的字段，避免覆盖商品信息
    // ✅ 重要：系统消息和发送的消息不应该更新sellerName，保留原有的sellerName
    if (messageData.seller_name && messageData.message_type !== 'system' && !is_sent_message) {
      sessionUpdate.sellerName = messageData.seller_name
    }
    if (messageData.item_title) {
      sessionUpdate.itemTitle = messageData.item_title
    }
    if (messageData.seller_avatar || messageData.avatar) {
      sessionUpdate.avatar = messageData.seller_avatar || messageData.avatar
    }
    
    // ✅ 调试日志：记录当前会话状态
    const beforeCurrentSession = chatStore.currentSessionId
    
    chatStore.addOrUpdateSession(sessionUpdate)
    
    // ✅ 调试日志：检查会话更新后是否影响了当前会话
    if (beforeCurrentSession && chatStore.currentSessionId !== beforeCurrentSession) {
      console.warn('[WebSocket] ⚠️ 会话更新后currentSessionId改变了!', {
        before: beforeCurrentSession,
        after: chatStore.currentSessionId,
        messageSessionId: sessionId
      })
    }
    
            // ✅ 添加消息到对应会话（会自动去重）
            const msg = {
              messageId: messageData.message_id,
              direction: messageData.direction,
              message_content: messageData.message_content,
              message_time: messageData.message_time,
              message_type: messageData.message_type || 'text',
              status: 'success', // WebSocket收到的消息都是成功发送的
              pending: false
            }
            
            // ✅ 如果是图片消息，添加图片信息
            if (messageData.message_type === 'image') {
              if (messageData.image_url) {
                msg.image_url = messageData.image_url
              }
              if (messageData.image_width) {
                msg.image_width = messageData.image_width
              }
              if (messageData.image_height) {
                msg.image_height = messageData.image_height
              }
            }
            
            // ✅ 如果是语音消息，添加语音信息
            if (messageData.message_type === 'voice') {
              if (messageData.voice_url) {
                msg.voice_url = messageData.voice_url
              }
              if (messageData.voice_duration !== undefined) {
                msg.voice_duration = messageData.voice_duration
              }
              if (messageData.voice_size_bytes !== undefined) {
                msg.voice_size_bytes = messageData.voice_size_bytes
              }
            }
            
            // ✅ 如果是系统消息（textCard），添加系统消息数据
            if (messageData.message_type === 'system' && messageData.system_data) {
              msg.system_data = messageData.system_data
            }
    
    chatStore.appendMessages(sessionId, [msg])
    
    // ✅ 如果这是发送的消息（direction='send'），尝试移除对应的乐观更新消息
    if (messageData.direction === 'send' && messageData.message_id) {
      // 查找是否有相同内容的乐观更新消息（通过localId标记的）
      const msgList = chatStore.messages[sessionId]
      if (msgList) {
        // ✅ 对于图片消息，通过 message_type 和 image_url 匹配
        // ✅ 对于文本消息，通过 message_content 匹配
        const optimisticIndex = msgList.findIndex(m => {
          if (!m.localId || m.messageId) return false // 必须是乐观更新的消息
          if (m.direction !== 'send') return false // 必须是发送方向
          
          // 如果是图片消息，通过 image_url 匹配
          if (messageData.message_type === 'image' && m.message_type === 'image') {
            return m.image_url === messageData.image_url
          }
          
          // 如果是文本消息，通过 message_content 匹配
          if (messageData.message_type === 'text' && m.message_type === 'text') {
            return m.message_content === messageData.message_content
          }
          
          return false
        })
        if (optimisticIndex !== -1) {
          const removedMsg = msgList[optimisticIndex]
          // 移除乐观更新的消息（真实消息已通过appendMessages添加）
          msgList.splice(optimisticIndex, 1)
          console.log('[WebSocket] ✅ 已移除乐观更新的消息，替换为真实消息:', {
            localId: removedMsg.localId,
            realMessageId: messageData.message_id,
            message_type: messageData.message_type,
            content: messageData.message_content?.substring(0, 20)
          })
        } else {
          console.warn('[WebSocket] ⚠️ 未找到匹配的乐观更新消息:', {
            message_id: messageData.message_id,
            message_type: messageData.message_type,
            content: messageData.message_content?.substring(0, 20),
            totalMessages: msgList.length,
            localMessages: msgList.filter(m => m.localId && !m.messageId).length
          })
        }
      }
    }
    
    // ✅ 如果是接收的消息，显示通知和更新未读数
    if (messageData.direction === 'recv') {
      // ✅ 如果当前会话就是该会话，自动滚动到底部（通过触发消息更新）
      // ⚠️ 注意：即使聊天窗口没有打开，也要正确处理未读数
      const isCurrentSession = chatStore.currentSessionId === sessionId
      const isChatVisible = chatStore.visible
      
      // ✅ 如果当前会话不是该会话，或者聊天窗口没有打开，增加未读计数
      if (!isCurrentSession || !isChatVisible) {
        const session = chatStore.sessions.find(s => s.sessionId === sessionId)
        if (session) {
          session.unread = (session.unread || 0) + 1
        } else {
          // ✅ 如果会话不存在，需要先添加会话（避免未读数丢失）
          // ✅ 使用上面已经构建好的sessionId（优先使用conversation_id或chat_id）
          const newSessionData = {
            sessionId: sessionId,  // ✅ 传递sessionId，确保使用conversation_id（可能包含chat_id）
            sellerId: messageData.seller_id,
            itemId: messageData.item_id,
            sellerName: messageData.seller_name || '未知卖家',
            lastMessage: messageData.message_content,
            lastTime: messageData.message_time,
            unread: 1
          }
          
          // ✅ 只有当头像存在时才传递，避免覆盖为空字符串
          if (messageData.seller_avatar || messageData.avatar) {
            newSessionData.avatar = messageData.seller_avatar || messageData.avatar
          }
          
          chatStore.addOrUpdateSession(newSessionData)
        }
        chatStore.incrementUnread()
        console.log('[WebSocket] ✅ 已更新未读数，当前总未读:', chatStore.unreadCount)
      }
      
      // ✅ 浏览器通知（仅在非当前会话或聊天窗口未打开时显示）
      if ((!isCurrentSession || !isChatVisible) && Notification.permission === 'granted') {
        const notification = new Notification('新消息', {
          body: `${messageData.seller_name || '卖家'}: ${messageData.message_content.substring(0, 50)}`,
          icon: '/favicon.ico',
          tag: `chat_${sessionId}`, // 使用会话ID作为tag，相同会话的通知会被替换
          requireInteraction: false, // 不强制用户交互
          data: {
            sessionId: sessionId,
            sellerId: messageData.seller_id,
            itemId: messageData.item_id,
            clientId: client_id
          }
        })
        
        // ✅ 点击通知时打开聊天窗口并切换到对应会话
        notification.onclick = () => {
          window.focus() // 聚焦到窗口
          notification.close()
          
          // 打开聊天窗口并切换到对应会话
          const chatStore = useChatStore()
          
          // 设置选中的客户端（如果不同的话）
          if (chatStore.selectedClientId !== client_id) {
            chatStore.selectClient(client_id)
          }
          
          // 打开聊天窗口
          chatStore.setVisible(true)
          
          // 切换到对应的会话
          if (sessionId) {
            chatStore.setCurrentSession(sessionId)
          }
        }
      }
      
      // ✅ 页面通知（仅在非当前会话或聊天窗口未打开时显示）
      if (!isCurrentSession || !isChatVisible) {
        ElNotification({
          title: '新消息',
          message: `${messageData.seller_name || '卖家'}: ${messageData.message_content.substring(0, 50)}`,
          type: 'info',
          duration: 3000,
          onClick: () => {
            // ✅ 点击通知时打开聊天窗口并切换到对应会话
            chatStore.setVisible(true)
            if (chatStore.selectedClientId !== client_id) {
              chatStore.selectClient(client_id)
            }
            if (sessionId) {
              chatStore.setCurrentSession(sessionId)
            }
          }
        })
      }
    }
  }

  /**
   * 处理状态更新事件（更新agentStore）
   */
  handleStatusUpdate(data) {
    if (data.type === 'status_update' && data.client_id && data.data) {
      try {
        const agentStore = useAgentStore()
        const existingClient = agentStore.clients.find(c => c.client_id === data.client_id)
        
        // 处理 online_status（兼容两种格式）
        let onlineStatus = 'offline'
        if (data.data.online_status) {
          onlineStatus = data.data.online_status
        } else if ('online' in data.data) {
          onlineStatus = data.data.online ? 'online' : 'offline'
        }
        
        if (existingClient) {
          // 更新现有客户端状态（保留关键字段，合并新数据）
          Object.assign(existingClient, {
            ...data.data,
            client_id: data.client_id,
            client_name: existingClient.client_name || data.data.client_name || existingClient.hostname || data.client_id,
            client_type: data.data.client_type || existingClient.client_type, // ✅ 使用合并后的client_type（从数据库读取）
            online_status: onlineStatus || existingClient.online_status || 'offline',
            login_status: data.data.login_status || existingClient.login_status || 'not_logged_in'
          })
        } else {
          // 新客户端，添加到列表
          agentStore.updateClient({
            client_id: data.client_id,
            ...data.data,
            client_name: data.data.client_name || data.data.hostname || data.client_id,
            client_type: data.data.client_type || 'search', // ✅ 使用合并后的client_type
            online_status: onlineStatus,
            login_status: data.data.login_status || 'not_logged_in'
          })
        }
      } catch (err) {
        console.debug('[WebSocket] 更新agentStore失败（不影响状态上报）:', err)
      }
    }
  }

  /**
   * 处理客户端响应消息
   */
  handleClientResponse(data) {
    const { message, client_id } = data
    const { event, success, msg, data: resData } = message

    // 根据不同的事件类型显示通知
    switch (event) {
      case 'login':
        if (success) {
          if (resData.type === 'qrcode' && resData.qrcode) {
            // 二维码登录 - 通知处理器显示二维码
            this.notifyHandlers({
              type: 'qrcode_login',
              client_id,
              qrcode: resData.qrcode,
              expires_in: resData.expires_in
            })
          } else if (resData.logged_in) {
            // 登录成功
            ElNotification({
              title: '登录成功',
              message: `客户端 ${client_id} 登录成功！账号: ${resData.account || '未知'}`,
              type: 'success',
              duration: 3000
            })
          }
        } else {
          // 登录失败
          ElNotification({
            title: '登录失败',
            message: msg || '未知错误',
            type: 'error',
            duration: 5000
          })
        }
        break
      
      case 'get_address':
        // 获取地址列表
        if (success) {
          this.notifyHandlers({
            type: 'address_list',
            client_id,
            addresses: resData.addresses || []
          })
        }
        break
      
      case 'search':
        // 搜索结果 - 不再弹出通知，只在任务状态中显示统计
        // 通知已移动到页面状态统计中，避免频繁弹窗打扰
        break
      
      case 'chat_message':
        // ✅ 聊天消息（从client_response中收到）
        if (success && resData) {
          console.log('[WebSocket] 收到client_response中的chat_message:', resData)
          // 转换为chat_message格式并调用handleChatMessage
          this.handleChatMessage({
            client_id: client_id,
            data: resData
          })
        } else {
          console.warn('[WebSocket] chat_message 失败:', msg)
        }
        break
      
      case 'chat_open':
        // 聊天窗口打开响应
        if (success && resData) {
          this.notifyHandlers({
            type: 'chat_opened',
            client_id,
            data: {
              seller_id: resData.seller_id,
              item_id: resData.item_id,
              seller_name: resData.seller_name,
              seller_avatar: resData.seller_avatar
            }
          })
          
          // 更新聊天会话的头像和seller_id（Agent返回的seller_id是从商品详情获取的纯数字ID）
          const chatStore = useChatStore()
          if (resData.seller_id) {
            // ✅ 构建sessionId（优先使用conversation_id或chat_id）
            const sessionId = resData.conversation_id || 
              resData.chat_id ||
              `${resData.seller_id || ''}#${resData.item_id || ''}`
            
            chatStore.addOrUpdateSession({
              sessionId: sessionId,  // ✅ 传递sessionId，确保使用conversation_id（可能包含chat_id）
              sellerId: resData.seller_id, // 使用Agent返回的纯数字seller_id
              sellerName: resData.seller_name,
              itemId: resData.item_id,
              itemTitle: resData.item_title || resData.itemTitle, // 更新商品标题
              itemPrice: resData.item_price || resData.itemPrice, // 更新价格
              itemImage: resData.item_image || resData.itemImage || resData.main_pic, // 更新商品图片
              itemTags: resData.item_tags || resData.itemTags || [], // 更新标签
              avatar: resData.seller_avatar || '', // 更新头像
            })
            // console.log('[WebSocket] 已更新会话信息:', {
            //   seller_id: resData.seller_id,
            //   seller_avatar: resData.seller_avatar,
            //   seller_name: resData.seller_name,
            //   item_image: resData.item_image,
            //   item_tags: resData.item_tags
            // }) // ✅ 已注释：日志太多
          }
        } else {
          console.warn('[WebSocket] chat_open 失败:', msg)
        }
        break
      
      case 'order':
        // 下单结果
        if (success) {
          ElNotification({
            title: '下单成功',
            message: `订单已创建`,
            type: 'success',
            duration: 3000
          })
        } else {
          ElNotification({
            title: '下单失败',
            message: msg || '未知错误',
            type: 'error',
            duration: 5000
          })
        }
        break
      
      case 'order_error':
        // 订单错误（业务错误或系统错误）
        const errorData = resData || {}
        const isBusinessError = errorData.is_business_error
        const isBanned = errorData.is_banned
        
        if (isBanned) {
          // 封禁错误：严重错误
          ElNotification({
            title: '订单失败（账号封禁）',
            message: msg || '账号已被封禁，无法下单',
            type: 'error',
            duration: 10000
          })
        } else if (isBusinessError) {
          // 业务错误：警告
          ElNotification({
            title: '订单警告',
            message: msg || '业务错误（如库存锁定、PC不支持等），已跳过继续尝试',
            type: 'warning',
            duration: 5000
          })
        } else {
          // 其他系统错误
          ElNotification({
            title: '订单失败',
            message: msg || '未知错误',
            type: 'error',
            duration: 5000
          })
        }
        break
      
      case 'api_error':
        // API错误
        ElNotification({
          title: 'API错误',
          message: msg || 'API请求异常',
          type: 'error',
          duration: 5000
        })
        break
    }

    // 通知所有处理器
    this.notifyHandlers(data)
  }

  /**
   * 发送命令到客户端
   * @param {string} clientId 客户端ID
   * @param {string} command 命令类型
   * @param {object} data 命令数据
   */
  sendCommand(clientId, command, data = {}) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      ElMessage.error('WebSocket未连接')
      return false
    }

    const message = {
      type: 'command',
      client_id: clientId,
      command: command,
      data: data
    }

    try {
      this.ws.send(JSON.stringify(message))
      console.log('📤 发送命令:', message)
      return true
    } catch (error) {
      console.error('发送命令失败:', error)
      ElMessage.error('发送命令失败')
      return false
    }
  }

  /**
   * 发送消息（通用方法）
   * @param {object} message 消息对象
   */
  send(message) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      console.warn('WebSocket未连接，无法发送消息')
      return false
    }

    try {
      this.ws.send(JSON.stringify(message))
      console.log('📤 发送消息:', message)
      return true
    } catch (error) {
      console.error('发送消息失败:', error)
      return false
    }
  }

  /**
   * 注册消息处理器
   * @param {function} handler 处理器函数
   */
  on(handler) {
    if (typeof handler === 'function') {
      this.messageHandlers.push(handler)
    }
  }

  /**
   * 移除消息处理器
   * @param {function} handler 处理器函数
   */
  off(handler) {
    const index = this.messageHandlers.indexOf(handler)
    if (index > -1) {
      this.messageHandlers.splice(index, 1)
    }
  }

  /**
   * 通知所有处理器
   */
  notifyHandlers(data) {
    this.messageHandlers.forEach(handler => {
      try {
        handler(data)
      } catch (error) {
        console.error('处理器执行错误:', error)
      }
    })
  }

  /**
   * 开始心跳
   */
  startHeartbeat() {
    this.stopHeartbeat()
    this.heartbeatTimer = setInterval(() => {
      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
        this.ws.send(JSON.stringify({ type: 'ping' }))
      }
    }, this.heartbeatInterval)
  }

  /**
   * 停止心跳
   */
  stopHeartbeat() {
    if (this.heartbeatTimer) {
      clearInterval(this.heartbeatTimer)
      this.heartbeatTimer = null
    }
  }

  /**
   * 安排重连
   */
  scheduleReconnect() {
    if (this.reconnectTimer) {
      return
    }

    console.log(`${this.reconnectDelay / 1000}秒后尝试重连...`)
    this.reconnectTimer = setTimeout(() => {
      this.reconnectTimer = null
      this.connect()
    }, this.reconnectDelay)
  }

  /**
   * 断开连接
   */
  disconnect() {
    if (this.reconnectTimer) {
      clearTimeout(this.reconnectTimer)
      this.reconnectTimer = null
    }

    this.stopHeartbeat()

    if (this.ws) {
      this.ws.close()
      this.ws = null
    }

    this.messageHandlers = []
  }

  /**
   * 获取连接状态
   */
  isConnected() {
    return this.ws && this.ws.readyState === WebSocket.OPEN
  }
}

// 创建全局WebSocket实例
const websocketManager = new WebSocketManager()

// 同时支持默认导出和命名导出
export { websocketManager }
export default websocketManager

